home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / mpeg_play-2.1 / decoders.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  30KB  |  937 lines
  1. /*
  2.  * decoders.c
  3.  *
  4.  * This file contains all the routines for Huffman decoding required in 
  5.  * MPEG
  6.  *
  7.  */
  8.  
  9. /*
  10.  * Copyright (c) 1995 The Regents of the University of California.
  11.  * All rights reserved.
  12.  * 
  13.  * Permission to use, copy, modify, and distribute this software and its
  14.  * documentation for any purpose, without fee, and without written agreement is
  15.  * hereby granted, provided that the above copyright notice and the following
  16.  * two paragraphs appear in all copies of this software.
  17.  * 
  18.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  19.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  20.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  21.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  22.  * 
  23.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  24.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  25.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  26.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  27.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  28.  */
  29.  
  30. #include <stdio.h>
  31. #include <assert.h>
  32. #include "decoders.h"
  33. #include "util.h" 
  34. #include "video.h"
  35. #include "proto.h"
  36.  
  37. /* Decoding table for macroblock_address_increment */
  38. mb_addr_inc_entry     mb_addr_inc[2048];
  39.  
  40. /* Decoding table for macroblock_type in predictive-coded pictures */
  41. mb_type_entry         mb_type_P[64];
  42.  
  43. /* Decoding table for macroblock_type in bidirectionally-coded pictures */
  44. mb_type_entry         mb_type_B[64];
  45.  
  46. /* Decoding table for motion vectors */
  47. motion_vectors_entry  motion_vectors[2048];
  48.  
  49. /* Decoding table for coded_block_pattern */
  50.  
  51. coded_block_pattern_entry coded_block_pattern[512] = 
  52. { {(unsigned int)ERROR, 0}, {(unsigned int)ERROR, 0}, {39, 9}, {27, 9}, {59, 9}, {55, 9}, {47, 9}, {31, 9},
  53.     {58, 8}, {58, 8}, {54, 8}, {54, 8}, {46, 8}, {46, 8}, {30, 8}, {30, 8},
  54.     {57, 8}, {57, 8}, {53, 8}, {53, 8}, {45, 8}, {45, 8}, {29, 8}, {29, 8},
  55.     {38, 8}, {38, 8}, {26, 8}, {26, 8}, {37, 8}, {37, 8}, {25, 8}, {25, 8},
  56.     {43, 8}, {43, 8}, {23, 8}, {23, 8}, {51, 8}, {51, 8}, {15, 8}, {15, 8},
  57.     {42, 8}, {42, 8}, {22, 8}, {22, 8}, {50, 8}, {50, 8}, {14, 8}, {14, 8},
  58.     {41, 8}, {41, 8}, {21, 8}, {21, 8}, {49, 8}, {49, 8}, {13, 8}, {13, 8},
  59.     {35, 8}, {35, 8}, {19, 8}, {19, 8}, {11, 8}, {11, 8}, {7, 8}, {7, 8},
  60.     {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
  61.     {10, 7}, {10, 7}, {10, 7}, {10, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7}, 
  62.     {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 
  63.     {9, 7}, {9, 7}, {9, 7}, {9, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, 
  64.     {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, 
  65.     {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, 
  66.     {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, 
  67.     {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, 
  68.     {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
  69.     {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
  70.     {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, 
  71.     {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, 
  72.     {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, 
  73.     {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, 
  74.     {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, 
  75.     {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, 
  76.     {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, 
  77.     {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, 
  78.     {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, 
  79.     {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, 
  80.     {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, 
  81.     {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, 
  82.     {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, 
  83.     {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, 
  84.     {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, 
  85.     {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, 
  86.     {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, 
  87.     {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, 
  88.     {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, 
  89.     {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, 
  90.     {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 
  91.     {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 
  92.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, 
  93.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, 
  94.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, 
  95.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, 
  96.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, 
  97.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, 
  98.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, 
  99.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, 
  100.     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, 
  101.     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, 
  102.     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, 
  103.     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
  104.     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
  105.     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, 
  106.     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, 
  107.     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
  108.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  109.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  110.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  111.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  112.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  113.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  114.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, 
  115.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}
  116. };
  117.  
  118. /* Decoding tables for dct_dc_size_luminance */
  119. dct_dc_size_entry dct_dc_size_luminance[32] =
  120. {   {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  121.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  122.     {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, 
  123.     {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {(unsigned int)ERROR, 0}
  124. };
  125.  
  126. dct_dc_size_entry dct_dc_size_luminance1[16] =
  127. {   {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6},
  128.     {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10, 9}, {11, 9}
  129. };
  130.  
  131. /* Decoding table for dct_dc_size_chrominance */
  132. dct_dc_size_entry dct_dc_size_chrominance[32] =
  133. {   {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  134.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  135.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  136.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {(unsigned int)ERROR, 0}
  137. };
  138.  
  139. dct_dc_size_entry dct_dc_size_chrominance1[32] =
  140. {   {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, 
  141.     {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, 
  142.     {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, 
  143.     {8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10, 10}, {11, 10}
  144. };
  145.  
  146. /* DCT coeff tables. */
  147.  
  148. unsigned short int dct_coeff_tbl_0[256] =
  149. {
  150. 0xffff, 0xffff, 0xffff, 0xffff, 
  151. 0xffff, 0xffff, 0xffff, 0xffff, 
  152. 0xffff, 0xffff, 0xffff, 0xffff, 
  153. 0xffff, 0xffff, 0xffff, 0xffff, 
  154. 0x052f, 0x051f, 0x050f, 0x04ff, 
  155. 0x183f, 0x402f, 0x3c2f, 0x382f, 
  156. 0x342f, 0x302f, 0x2c2f, 0x7c1f, 
  157. 0x781f, 0x741f, 0x701f, 0x6c1f, 
  158. 0x028e, 0x028e, 0x027e, 0x027e, 
  159. 0x026e, 0x026e, 0x025e, 0x025e, 
  160. 0x024e, 0x024e, 0x023e, 0x023e, 
  161. 0x022e, 0x022e, 0x021e, 0x021e, 
  162. 0x020e, 0x020e, 0x04ee, 0x04ee, 
  163. 0x04de, 0x04de, 0x04ce, 0x04ce, 
  164. 0x04be, 0x04be, 0x04ae, 0x04ae, 
  165. 0x049e, 0x049e, 0x048e, 0x048e, 
  166. 0x01fd, 0x01fd, 0x01fd, 0x01fd, 
  167. 0x01ed, 0x01ed, 0x01ed, 0x01ed, 
  168. 0x01dd, 0x01dd, 0x01dd, 0x01dd, 
  169. 0x01cd, 0x01cd, 0x01cd, 0x01cd, 
  170. 0x01bd, 0x01bd, 0x01bd, 0x01bd, 
  171. 0x01ad, 0x01ad, 0x01ad, 0x01ad, 
  172. 0x019d, 0x019d, 0x019d, 0x019d, 
  173. 0x018d, 0x018d, 0x018d, 0x018d, 
  174. 0x017d, 0x017d, 0x017d, 0x017d, 
  175. 0x016d, 0x016d, 0x016d, 0x016d, 
  176. 0x015d, 0x015d, 0x015d, 0x015d, 
  177. 0x014d, 0x014d, 0x014d, 0x014d, 
  178. 0x013d, 0x013d, 0x013d, 0x013d, 
  179. 0x012d, 0x012d, 0x012d, 0x012d, 
  180. 0x011d, 0x011d, 0x011d, 0x011d, 
  181. 0x010d, 0x010d, 0x010d, 0x010d, 
  182. 0x282c, 0x282c, 0x282c, 0x282c, 
  183. 0x282c, 0x282c, 0x282c, 0x282c, 
  184. 0x242c, 0x242c, 0x242c, 0x242c, 
  185. 0x242c, 0x242c, 0x242c, 0x242c, 
  186. 0x143c, 0x143c, 0x143c, 0x143c, 
  187. 0x143c, 0x143c, 0x143c, 0x143c, 
  188. 0x0c4c, 0x0c4c, 0x0c4c, 0x0c4c, 
  189. 0x0c4c, 0x0c4c, 0x0c4c, 0x0c4c, 
  190. 0x085c, 0x085c, 0x085c, 0x085c, 
  191. 0x085c, 0x085c, 0x085c, 0x085c, 
  192. 0x047c, 0x047c, 0x047c, 0x047c, 
  193. 0x047c, 0x047c, 0x047c, 0x047c, 
  194. 0x046c, 0x046c, 0x046c, 0x046c, 
  195. 0x046c, 0x046c, 0x046c, 0x046c, 
  196. 0x00fc, 0x00fc, 0x00fc, 0x00fc, 
  197. 0x00fc, 0x00fc, 0x00fc, 0x00fc, 
  198. 0x00ec, 0x00ec, 0x00ec, 0x00ec, 
  199. 0x00ec, 0x00ec, 0x00ec, 0x00ec, 
  200. 0x00dc, 0x00dc, 0x00dc, 0x00dc, 
  201. 0x00dc, 0x00dc, 0x00dc, 0x00dc, 
  202. 0x00cc, 0x00cc, 0x00cc, 0x00cc, 
  203. 0x00cc, 0x00cc, 0x00cc, 0x00cc, 
  204. 0x681c, 0x681c, 0x681c, 0x681c, 
  205. 0x681c, 0x681c, 0x681c, 0x681c, 
  206. 0x641c, 0x641c, 0x641c, 0x641c, 
  207. 0x641c, 0x641c, 0x641c, 0x641c, 
  208. 0x601c, 0x601c, 0x601c, 0x601c, 
  209. 0x601c, 0x601c, 0x601c, 0x601c, 
  210. 0x5c1c, 0x5c1c, 0x5c1c, 0x5c1c, 
  211. 0x5c1c, 0x5c1c, 0x5c1c, 0x5c1c, 
  212. 0x581c, 0x581c, 0x581c, 0x581c, 
  213. 0x581c, 0x581c, 0x581c, 0x581c, 
  214. };
  215.  
  216. unsigned short int dct_coeff_tbl_1[16] = 
  217. {
  218. 0x00bb, 0x202b, 0x103b, 0x00ab, 
  219. 0x084b, 0x1c2b, 0x541b, 0x501b, 
  220. 0x009b, 0x4c1b, 0x481b, 0x045b, 
  221. 0x0c3b, 0x008b, 0x182b, 0x441b, 
  222. };
  223.  
  224. unsigned short int dct_coeff_tbl_2[4] =
  225. {
  226. 0x4019, 0x1429, 0x0079, 0x0839, 
  227. };
  228.  
  229. unsigned short int dct_coeff_tbl_3[4] = 
  230. {
  231. 0x0449, 0x3c19, 0x3819, 0x1029, 
  232. };
  233.  
  234. unsigned short int dct_coeff_next[256] = 
  235. {
  236. 0xffff, 0xffff, 0xffff, 0xffff, 
  237. 0xf7d5, 0xf7d5, 0xf7d5, 0xf7d5, 
  238. 0x0826, 0x0826, 0x2416, 0x2416, 
  239. 0x0046, 0x0046, 0x2016, 0x2016, 
  240. 0x1c15, 0x1c15, 0x1c15, 0x1c15, 
  241. 0x1815, 0x1815, 0x1815, 0x1815, 
  242. 0x0425, 0x0425, 0x0425, 0x0425, 
  243. 0x1415, 0x1415, 0x1415, 0x1415, 
  244. 0x3417, 0x0067, 0x3017, 0x2c17, 
  245. 0x0c27, 0x0437, 0x0057, 0x2817, 
  246. 0x0034, 0x0034, 0x0034, 0x0034, 
  247. 0x0034, 0x0034, 0x0034, 0x0034, 
  248. 0x1014, 0x1014, 0x1014, 0x1014, 
  249. 0x1014, 0x1014, 0x1014, 0x1014, 
  250. 0x0c14, 0x0c14, 0x0c14, 0x0c14, 
  251. 0x0c14, 0x0c14, 0x0c14, 0x0c14, 
  252. 0x0023, 0x0023, 0x0023, 0x0023, 
  253. 0x0023, 0x0023, 0x0023, 0x0023, 
  254. 0x0023, 0x0023, 0x0023, 0x0023, 
  255. 0x0023, 0x0023, 0x0023, 0x0023, 
  256. 0x0813, 0x0813, 0x0813, 0x0813, 
  257. 0x0813, 0x0813, 0x0813, 0x0813, 
  258. 0x0813, 0x0813, 0x0813, 0x0813, 
  259. 0x0813, 0x0813, 0x0813, 0x0813, 
  260. 0x0412, 0x0412, 0x0412, 0x0412, 
  261. 0x0412, 0x0412, 0x0412, 0x0412, 
  262. 0x0412, 0x0412, 0x0412, 0x0412, 
  263. 0x0412, 0x0412, 0x0412, 0x0412, 
  264. 0x0412, 0x0412, 0x0412, 0x0412, 
  265. 0x0412, 0x0412, 0x0412, 0x0412, 
  266. 0x0412, 0x0412, 0x0412, 0x0412, 
  267. 0x0412, 0x0412, 0x0412, 0x0412, 
  268. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  269. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  270. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  271. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  272. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  273. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  274. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  275. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  276. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  277. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  278. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  279. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  280. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  281. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  282. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  283. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  284. 0x0011, 0x0011, 0x0011, 0x0011, 
  285. 0x0011, 0x0011, 0x0011, 0x0011, 
  286. 0x0011, 0x0011, 0x0011, 0x0011, 
  287. 0x0011, 0x0011, 0x0011, 0x0011, 
  288. 0x0011, 0x0011, 0x0011, 0x0011, 
  289. 0x0011, 0x0011, 0x0011, 0x0011, 
  290. 0x0011, 0x0011, 0x0011, 0x0011, 
  291. 0x0011, 0x0011, 0x0011, 0x0011, 
  292. 0x0011, 0x0011, 0x0011, 0x0011, 
  293. 0x0011, 0x0011, 0x0011, 0x0011, 
  294. 0x0011, 0x0011, 0x0011, 0x0011, 
  295. 0x0011, 0x0011, 0x0011, 0x0011, 
  296. 0x0011, 0x0011, 0x0011, 0x0011, 
  297. 0x0011, 0x0011, 0x0011, 0x0011, 
  298. 0x0011, 0x0011, 0x0011, 0x0011, 
  299. 0x0011, 0x0011, 0x0011, 0x0011, 
  300. };
  301.  
  302. unsigned short int dct_coeff_first[256] = 
  303. {
  304. 0xffff, 0xffff, 0xffff, 0xffff, 
  305. 0xf7d5, 0xf7d5, 0xf7d5, 0xf7d5, 
  306. 0x0826, 0x0826, 0x2416, 0x2416, 
  307. 0x0046, 0x0046, 0x2016, 0x2016, 
  308. 0x1c15, 0x1c15, 0x1c15, 0x1c15, 
  309. 0x1815, 0x1815, 0x1815, 0x1815, 
  310. 0x0425, 0x0425, 0x0425, 0x0425, 
  311. 0x1415, 0x1415, 0x1415, 0x1415, 
  312. 0x3417, 0x0067, 0x3017, 0x2c17, 
  313. 0x0c27, 0x0437, 0x0057, 0x2817, 
  314. 0x0034, 0x0034, 0x0034, 0x0034, 
  315. 0x0034, 0x0034, 0x0034, 0x0034, 
  316. 0x1014, 0x1014, 0x1014, 0x1014, 
  317. 0x1014, 0x1014, 0x1014, 0x1014, 
  318. 0x0c14, 0x0c14, 0x0c14, 0x0c14, 
  319. 0x0c14, 0x0c14, 0x0c14, 0x0c14, 
  320. 0x0023, 0x0023, 0x0023, 0x0023, 
  321. 0x0023, 0x0023, 0x0023, 0x0023, 
  322. 0x0023, 0x0023, 0x0023, 0x0023, 
  323. 0x0023, 0x0023, 0x0023, 0x0023, 
  324. 0x0813, 0x0813, 0x0813, 0x0813, 
  325. 0x0813, 0x0813, 0x0813, 0x0813, 
  326. 0x0813, 0x0813, 0x0813, 0x0813, 
  327. 0x0813, 0x0813, 0x0813, 0x0813, 
  328. 0x0412, 0x0412, 0x0412, 0x0412, 
  329. 0x0412, 0x0412, 0x0412, 0x0412, 
  330. 0x0412, 0x0412, 0x0412, 0x0412, 
  331. 0x0412, 0x0412, 0x0412, 0x0412, 
  332. 0x0412, 0x0412, 0x0412, 0x0412, 
  333. 0x0412, 0x0412, 0x0412, 0x0412, 
  334. 0x0412, 0x0412, 0x0412, 0x0412, 
  335. 0x0412, 0x0412, 0x0412, 0x0412, 
  336. 0x0010, 0x0010, 0x0010, 0x0010, 
  337. 0x0010, 0x0010, 0x0010, 0x0010, 
  338. 0x0010, 0x0010, 0x0010, 0x0010, 
  339. 0x0010, 0x0010, 0x0010, 0x0010, 
  340. 0x0010, 0x0010, 0x0010, 0x0010, 
  341. 0x0010, 0x0010, 0x0010, 0x0010, 
  342. 0x0010, 0x0010, 0x0010, 0x0010, 
  343. 0x0010, 0x0010, 0x0010, 0x0010, 
  344. 0x0010, 0x0010, 0x0010, 0x0010, 
  345. 0x0010, 0x0010, 0x0010, 0x0010, 
  346. 0x0010, 0x0010, 0x0010, 0x0010, 
  347. 0x0010, 0x0010, 0x0010, 0x0010, 
  348. 0x0010, 0x0010, 0x0010, 0x0010, 
  349. 0x0010, 0x0010, 0x0010, 0x0010, 
  350. 0x0010, 0x0010, 0x0010, 0x0010, 
  351. 0x0010, 0x0010, 0x0010, 0x0010, 
  352. 0x0010, 0x0010, 0x0010, 0x0010, 
  353. 0x0010, 0x0010, 0x0010, 0x0010, 
  354. 0x0010, 0x0010, 0x0010, 0x0010, 
  355. 0x0010, 0x0010, 0x0010, 0x0010, 
  356. 0x0010, 0x0010, 0x0010, 0x0010, 
  357. 0x0010, 0x0010, 0x0010, 0x0010, 
  358. 0x0010, 0x0010, 0x0010, 0x0010, 
  359. 0x0010, 0x0010, 0x0010, 0x0010, 
  360. 0x0010, 0x0010, 0x0010, 0x0010, 
  361. 0x0010, 0x0010, 0x0010, 0x0010, 
  362. 0x0010, 0x0010, 0x0010, 0x0010, 
  363. 0x0010, 0x0010, 0x0010, 0x0010, 
  364. 0x0010, 0x0010, 0x0010, 0x0010, 
  365. 0x0010, 0x0010, 0x0010, 0x0010, 
  366. 0x0010, 0x0010, 0x0010, 0x0010, 
  367. 0x0010, 0x0010, 0x0010, 0x0010, 
  368. };
  369.  
  370. /* Macro for filling up the decoding table for mb_addr_inc */
  371. #define ASSIGN1(start, end, step, val, num) \
  372.   for (i = start; i < end; i+= step) { \
  373.     for (j = 0; j < step; j++) { \
  374.       mb_addr_inc[i+j].value = val; \
  375.       mb_addr_inc[i+j].num_bits = num; \
  376.     } \
  377.     val--; \
  378.     }
  379.  
  380.  
  381.  
  382. /*
  383.  *--------------------------------------------------------------
  384.  *
  385.  * init_mb_addr_inc --
  386.  *
  387.  *    Initialize the VLC decoding table for macro_block_address_increment
  388.  *
  389.  * Results:
  390.  *    The decoding table for macro_block_address_increment will
  391.  *      be filled; illegal values will be filled as ERROR.
  392.  *
  393.  * Side effects:
  394.  *    The global array mb_addr_inc will be filled.
  395.  *
  396.  *--------------------------------------------------------------
  397.  */
  398. static void
  399. init_mb_addr_inc()
  400. {
  401.   int i, j, val;
  402.  
  403.   for (i = 0; i < 8; i++) {
  404.     mb_addr_inc[i].value = ERROR;
  405.     mb_addr_inc[i].num_bits = 0;
  406.   }
  407.  
  408.   mb_addr_inc[8].value = MACRO_BLOCK_ESCAPE;
  409.   mb_addr_inc[8].num_bits = 11;
  410.  
  411.   for (i = 9; i < 15; i++) {
  412.     mb_addr_inc[i].value = ERROR;
  413.     mb_addr_inc[i].num_bits = 0;
  414.   }
  415.  
  416.   mb_addr_inc[15].value = MACRO_BLOCK_STUFFING;
  417.   mb_addr_inc[15].num_bits = 11;
  418.  
  419.   for (i = 16; i < 24; i++) {
  420.     mb_addr_inc[i].value = ERROR;
  421.     mb_addr_inc[i].num_bits = 0;
  422.   }
  423.  
  424.   val = 33;
  425.  
  426.   ASSIGN1(24, 36, 1, val, 11);
  427.   ASSIGN1(36, 48, 2, val, 10);
  428.   ASSIGN1(48, 96, 8, val, 8);
  429.   ASSIGN1(96, 128, 16, val, 7);
  430.   ASSIGN1(128, 256, 64, val, 5);
  431.   ASSIGN1(256, 512, 128, val, 4);
  432.   ASSIGN1(512, 1024, 256, val, 3);
  433.   ASSIGN1(1024, 2048, 1024, val, 1);
  434. }
  435.  
  436.  
  437. /* Macro for filling up the decoding table for mb_type */
  438. #define ASSIGN2(start, end, quant, motion_forward, motion_backward, pattern, intra, num, mb_type) \
  439.   for (i = start; i < end; i ++) { \
  440.     mb_type[i].mb_quant = quant; \
  441.     mb_type[i].mb_motion_forward = motion_forward; \
  442.     mb_type[i].mb_motion_backward = motion_backward; \
  443.     mb_type[i].mb_pattern = pattern; \
  444.     mb_type[i].mb_intra = intra; \
  445.     mb_type[i].num_bits = num; \
  446.   }
  447.      
  448.  
  449.  
  450. /*
  451.  *--------------------------------------------------------------
  452.  *
  453.  * init_mb_type_P --
  454.  *
  455.  *    Initialize the VLC decoding table for macro_block_type in
  456.  *      predictive-coded pictures.
  457.  *
  458.  * Results:
  459.  *    The decoding table for macro_block_type in predictive-coded
  460.  *      pictures will be filled; illegal values will be filled as ERROR.
  461.  *
  462.  * Side effects:
  463.  *    The global array mb_type_P will be filled.
  464.  *
  465.  *--------------------------------------------------------------
  466.  */
  467. static void
  468. init_mb_type_P()
  469. {
  470.   int i;
  471.  
  472.   mb_type_P[0].mb_quant = mb_type_P[0].mb_motion_forward 
  473.     = mb_type_P[0].mb_motion_backward = mb_type_P[0].mb_pattern 
  474.       = mb_type_P[0].mb_intra = ERROR;
  475.   mb_type_P[0].num_bits = 0;
  476.  
  477.   ASSIGN2(1, 2, 1, 0, 0, 0, 1, 6, mb_type_P)
  478.   ASSIGN2(2, 4, 1, 0, 0, 1, 0, 5, mb_type_P)
  479.   ASSIGN2(4, 6, 1, 1, 0, 1, 0, 5, mb_type_P);
  480.   ASSIGN2(6, 8, 0, 0, 0, 0, 1, 5, mb_type_P);
  481.   ASSIGN2(8, 16, 0, 1, 0, 0, 0, 3, mb_type_P);
  482.   ASSIGN2(16, 32, 0, 0, 0, 1, 0, 2, mb_type_P);
  483.   ASSIGN2(32, 64, 0, 1, 0, 1, 0, 1, mb_type_P);
  484. }
  485.  
  486.  
  487.  
  488.  
  489. /*
  490.  *--------------------------------------------------------------
  491.  *
  492.  * init_mb_type_B --
  493.  *
  494.  *    Initialize the VLC decoding table for macro_block_type in
  495.  *      bidirectionally-coded pictures.
  496.  *
  497.  * Results:
  498.  *    The decoding table for macro_block_type in bidirectionally-coded
  499.  *      pictures will be filled; illegal values will be filled as ERROR.
  500.  *
  501.  * Side effects:
  502.  *    The global array mb_type_B will be filled.
  503.  *
  504.  *--------------------------------------------------------------
  505.  */
  506. static void
  507. init_mb_type_B()
  508. {
  509.   int i;
  510.  
  511.   mb_type_B[0].mb_quant = mb_type_B[0].mb_motion_forward 
  512.     = mb_type_B[0].mb_motion_backward = mb_type_B[0].mb_pattern 
  513.       = mb_type_B[0].mb_intra = ERROR;
  514.   mb_type_B[0].num_bits = 0;
  515.  
  516.   ASSIGN2(1, 2, 1, 0, 0, 0, 1, 6, mb_type_B);
  517.   ASSIGN2(2, 3, 1, 0, 1, 1, 0, 6, mb_type_B);
  518.   ASSIGN2(3, 4, 1, 1, 0, 1, 0, 6, mb_type_B);
  519.   ASSIGN2(4, 6, 1, 1, 1, 1, 0, 5, mb_type_B);
  520.   ASSIGN2(6, 8, 0, 0, 0, 0, 1, 5, mb_type_B);
  521.   ASSIGN2(8, 12, 0, 1, 0, 0, 0, 4, mb_type_B);
  522.   ASSIGN2(12, 16, 0, 1, 0, 1, 0, 4, mb_type_B);
  523.   ASSIGN2(16, 24, 0, 0, 1, 0, 0, 3, mb_type_B);
  524.   ASSIGN2(24, 32, 0, 0, 1, 1, 0, 3, mb_type_B);
  525.   ASSIGN2(32, 48, 0, 1, 1, 0, 0, 2, mb_type_B);
  526.   ASSIGN2(48, 64, 0, 1, 1, 1, 0, 2, mb_type_B);
  527. }
  528.  
  529.  
  530. /* Macro for filling up the decoding tables for motion_vectors */
  531. #define ASSIGN3(start, end, step, val, num) \
  532.   for (i = start; i < end; i+= step) { \
  533.     for (j = 0; j < step / 2; j++) { \
  534.       motion_vectors[i+j].code = val; \
  535.       motion_vectors[i+j].num_bits = num; \
  536.     } \
  537.     for (j = step / 2; j < step; j++) { \
  538.       motion_vectors[i+j].code = -val; \
  539.       motion_vectors[i+j].num_bits = num; \
  540.     } \
  541.     val--; \
  542.   }
  543.  
  544.  
  545.  
  546. /*
  547.  *--------------------------------------------------------------
  548.  *
  549.  * init_motion_vectors --
  550.  *
  551.  *    Initialize the VLC decoding table for the various motion
  552.  *      vectors, including motion_horizontal_forward_code, 
  553.  *      motion_vertical_forward_code, motion_horizontal_backward_code,
  554.  *      and motion_vertical_backward_code.
  555.  *
  556.  * Results:
  557.  *    The decoding table for the motion vectors will be filled;
  558.  *      illegal values will be filled as ERROR.
  559.  *
  560.  * Side effects:
  561.  *    The global array motion_vector will be filled.
  562.  *
  563.  *--------------------------------------------------------------
  564.  */
  565. static void
  566. init_motion_vectors()
  567. {
  568.   int i, j, val = 16;
  569.  
  570.   for (i = 0; i < 24; i++) {
  571.     motion_vectors[i].code = ERROR;
  572.     motion_vectors[i].num_bits = 0;
  573.   }
  574.  
  575.   ASSIGN3(24, 36, 2, val, 11);
  576.   ASSIGN3(36, 48, 4, val, 10);
  577.   ASSIGN3(48, 96, 16, val, 8);
  578.   ASSIGN3(96, 128, 32, val, 7);
  579.   ASSIGN3(128, 256, 128, val, 5);
  580.   ASSIGN3(256, 512, 256, val, 4);
  581.   ASSIGN3(512, 1024, 512, val, 3);
  582.   ASSIGN3(1024, 2048, 1024, val, 1);
  583. }
  584.  
  585.  
  586.  
  587. extern void init_pre_idct();
  588.  
  589.  
  590. /*
  591.  *--------------------------------------------------------------
  592.  *
  593.  * init_tables --
  594.  *
  595.  *    Initialize all the tables for VLC decoding; this must be
  596.  *      called when the system is set up before any decoding can
  597.  *      take place.
  598.  *
  599.  * Results:
  600.  *    All the decoding tables will be filled accordingly.
  601.  *
  602.  * Side effects:
  603.  *    The corresponding global array for each decoding table 
  604.  *      will be filled.
  605.  *
  606.  *--------------------------------------------------------------
  607.  */    
  608. void
  609. init_tables()
  610. {
  611.  
  612.   init_mb_addr_inc();
  613.   init_mb_type_P();
  614.   init_mb_type_B();
  615.   init_motion_vectors();
  616.  
  617. #ifdef FLOATDCT
  618.   if (qualityFlag)
  619.     init_float_idct();
  620.   else
  621. #endif
  622.     init_pre_idct();
  623.  
  624. #ifdef ANALYSIS
  625.   {
  626.     init_stats();
  627.   }
  628. #endif
  629. }
  630.  
  631.  
  632. /*
  633.  *--------------------------------------------------------------
  634.  *
  635.  * DecodeDCTDCSizeLum --
  636.  *
  637.  *    Huffman Decoder for dct_dc_size_luminance; location where
  638.  *      the result of decoding will be placed is passed as argument.
  639.  *      The decoded values are obtained by doing a table lookup on
  640.  *      dct_dc_size_luminance.
  641.  *
  642.  * Results:
  643.  *    The decoded value for dct_dc_size_luminance or ERROR for 
  644.  *      unbound values will be placed in the location specified.
  645.  *
  646.  * Side effects:
  647.  *    Bit stream is irreversibly parsed.
  648.  *
  649.  *--------------------------------------------------------------
  650.  */        
  651. void
  652. decodeDCTDCSizeLum(value)
  653. unsigned int *value;
  654. {
  655.   unsigned int index;
  656.  
  657.   show_bits5(index);
  658.   
  659.   if (index < 31) {
  660.       *value = dct_dc_size_luminance[index].value;
  661.       flush_bits(dct_dc_size_luminance[index].num_bits);
  662.   }
  663.   else {
  664.     show_bits9(index);
  665.     index -= 0x1f0;
  666.     *value = dct_dc_size_luminance1[index].value;
  667.     flush_bits(dct_dc_size_luminance1[index].num_bits);
  668.   }
  669. }
  670.  
  671.  
  672.  
  673.  
  674. /*
  675.  *--------------------------------------------------------------
  676.  *
  677.  * DecodeDCTDCSizeChrom --
  678.  *
  679.  *    Huffman Decoder for dct_dc_size_chrominance; location where
  680.  *      the result of decoding will be placed is passed as argument.
  681.  *      The decoded values are obtained by doing a table lookup on
  682.  *      dct_dc_size_chrominance.
  683.  *
  684.  * Results:
  685.  *    The decoded value for dct_dc_size_chrominance or ERROR for
  686.  *      unbound values will be placed in the location specified.
  687.  *
  688.  * Side effects:
  689.  *    Bit stream is irreversibly parsed.
  690.  *
  691.  *--------------------------------------------------------------
  692.  */    
  693. void    
  694. decodeDCTDCSizeChrom(value)
  695. unsigned int *value;
  696. {
  697.   unsigned int index;
  698.  
  699.   show_bits5(index);
  700.   
  701.   if (index < 31) {
  702.       *value = dct_dc_size_chrominance[index].value;
  703.       flush_bits(dct_dc_size_chrominance[index].num_bits);
  704.   }
  705.   else {
  706.     show_bits10(index);
  707.     index -= 0x3e0;
  708.     *value = dct_dc_size_chrominance1[index].value;
  709.     flush_bits(dct_dc_size_chrominance1[index].num_bits);
  710.   }
  711. }
  712.  
  713.  
  714.  
  715. /*
  716.  *--------------------------------------------------------------
  717.  *
  718.  * decodeDCTCoeff --
  719.  *
  720.  *    Huffman Decoder for dct_coeff_first and dct_coeff_next;
  721.  *      locations where the results of decoding: run and level, are to
  722.  *      be placed and also the type of DCT coefficients, either
  723.  *      dct_coeff_first or dct_coeff_next, are being passed as argument.
  724.  *      
  725.  *      The decoder first examines the next 8 bits in the input stream,
  726.  *      and perform according to the following cases:
  727.  *      
  728.  *      '0000 0000' - examine 8 more bits (i.e. 16 bits total) and
  729.  *                    perform a table lookup on dct_coeff_tbl_0.
  730.  *                    One more bit is then examined to determine the sign
  731.  *                    of level.
  732.  *
  733.  *      '0000 0001' - examine 4 more bits (i.e. 12 bits total) and 
  734.  *                    perform a table lookup on dct_coeff_tbl_1.
  735.  *                    One more bit is then examined to determine the sign
  736.  *                    of level.
  737.  *      
  738.  *      '0000 0010' - examine 2 more bits (i.e. 10 bits total) and
  739.  *                    perform a table lookup on dct_coeff_tbl_2.
  740.  *                    One more bit is then examined to determine the sign
  741.  *                    of level.
  742.  *
  743.  *      '0000 0011' - examine 2 more bits (i.e. 10 bits total) and 
  744.  *                    perform a table lookup on dct_coeff_tbl_3.
  745.  *                    One more bit is then examined to determine the sign
  746.  *                    of level.
  747.  *
  748.  *      otherwise   - perform a table lookup on dct_coeff_tbl. If the
  749.  *                    value of run is not ESCAPE, extract one more bit
  750.  *                    to determine the sign of level; otherwise 6 more
  751.  *                    bits will be extracted to obtain the actual value 
  752.  *                    of run , and then 8 or 16 bits to get the value of level.
  753.  *                    
  754.  *      
  755.  *
  756.  * Results:
  757.  *    The decoded values of run and level or ERROR for unbound values
  758.  *      are placed in the locations specified.
  759.  *
  760.  * Side effects:
  761.  *    Bit stream is irreversibly parsed.
  762.  *
  763.  *--------------------------------------------------------------
  764.  */
  765. static void
  766. decodeDCTCoeff(dct_coeff_tbl, run, level)
  767. unsigned short int *dct_coeff_tbl;                                       
  768. unsigned int *run;
  769. int *level;
  770. {
  771.   unsigned int temp, index /*, num_bits */;
  772.   unsigned int value, next32bits, flushed;
  773.  
  774.   /*
  775.    * Grab the next 32 bits and use it to improve performance of
  776.    * getting the bits to parse. Thus, calls are translated as:
  777.    *
  778.    *    show_bitsX  <-->   next32bits >> (32-X)
  779.    *    get_bitsX   <-->   val = next32bits >> (32-flushed-X);
  780.    *               flushed += X;
  781.    *               next32bits &= bitMask[flushed];
  782.    *    flush_bitsX <-->   flushed += X;
  783.    *               next32bits &= bitMask[flushed];
  784.    *
  785.    */
  786.   show_bits32(next32bits);
  787.   flushed = 0;
  788.  
  789.   /* show_bits8(index); */
  790.   index = next32bits >> 24;
  791.  
  792.   if (index > 3) {
  793.     value = dct_coeff_tbl[index];
  794.     *run = (value & RUN_MASK) >> RUN_SHIFT;
  795.     if (*run == END_OF_BLOCK) {
  796.       *level = END_OF_BLOCK;
  797.     }
  798.     else {
  799.       /* num_bits = (value & NUM_MASK) + 1; */
  800.       /* flush_bits(num_bits); */
  801.       flushed = (value & NUM_MASK) + 1;
  802.       next32bits &= bitMask[flushed];
  803.       if (*run != ESCAPE) {
  804.          *level = (value & LEVEL_MASK) >> LEVEL_SHIFT;
  805.      /* get_bits1(value); */
  806.      /* if (value) *level = -*level; */
  807.      if (next32bits >> (31-flushed)) *level = -*level;
  808.      flushed++;
  809.      /* next32bits &= bitMask[flushed];  last op before update */
  810.        }
  811.        else {    /* *run == ESCAPE */
  812.          /* get_bits14(temp); */
  813.      temp = next32bits >> (18-flushed);
  814.      flushed += 14;
  815.      next32bits &= bitMask[flushed];
  816.      *run = temp >> 8;
  817.      temp &= 0xff;
  818.      if (temp == 0) {
  819.             /* get_bits8(*level); */
  820.         *level = next32bits >> (24-flushed);
  821.         flushed += 8;
  822.         /* next32bits &= bitMask[flushed];  last op before update */
  823.          assert(*level >= 128);
  824.      } else if (temp != 128) {
  825.         /* Grab sign bit */
  826.         *level = ((int) (temp << 24)) >> 24;
  827.      } else {
  828.             /* get_bits8(*level); */
  829.         *level = next32bits >> (24-flushed);
  830.         flushed += 8;
  831.         /* next32bits &= bitMask[flushed];  last op before update */
  832.         *level = *level - 256;
  833.         assert(*level <= -128 && *level >= -255);
  834.      }
  835.        }
  836.        /* Update bitstream... */
  837.        flush_bits(flushed);
  838.     }
  839.   }
  840.   else {
  841.     if (index == 2) { 
  842.       /* show_bits10(index); */
  843.       index = next32bits >> 22;
  844.       value = dct_coeff_tbl_2[index & 3];
  845.     }
  846.     else if (index == 3) { 
  847.       /* show_bits10(index); */
  848.       index = next32bits >> 22;
  849.       value = dct_coeff_tbl_3[index & 3];
  850.     }
  851.     else if (index) {    /* index == 1 */
  852.       /* show_bits12(index); */
  853.       index = next32bits >> 20;
  854.       value = dct_coeff_tbl_1[index & 15];
  855.     }
  856.     else {   /* index == 0 */
  857.       /* show_bits16(index); */
  858.       index = next32bits >> 16;
  859.       value = dct_coeff_tbl_0[index & 255];
  860.     }
  861.     *run = (value & RUN_MASK) >> RUN_SHIFT;
  862.     *level = (value & LEVEL_MASK) >> LEVEL_SHIFT;
  863.  
  864.     /*
  865.      * Fold these operations together to make it fast...
  866.      */
  867.     /* num_bits = (value & NUM_MASK) + 1; */
  868.     /* flush_bits(num_bits); */
  869.     /* get_bits1(value); */
  870.     /* if (value) *level = -*level; */
  871.  
  872.     flushed = (value & NUM_MASK) + 2;
  873.     if ((next32bits >> (32-flushed)) & 0x1) *level = -*level;
  874.  
  875.     /* Update bitstream ... */
  876.     flush_bits(flushed);
  877.   }
  878. }
  879.  
  880.  
  881. /*
  882.  *--------------------------------------------------------------
  883.  *
  884.  * decodeDCTCoeffFirst --
  885.  *
  886.  *    Huffman Decoder for dct_coeff_first. Locations for the
  887.  *      decoded results: run and level, are being passed as
  888.  *      arguments. Actual work is being done by calling DecodeDCTCoeff,
  889.  *      with the table dct_coeff_first.
  890.  *
  891.  * Results:
  892.  *    The decoded values of run and level for dct_coeff_first or
  893.  *      ERROR for unbound values are placed in the locations given.
  894.  *
  895.  * Side effects:
  896.  *    Bit stream is irreversibly parsed.
  897.  *
  898.  *--------------------------------------------------------------
  899.  */        
  900. void
  901. decodeDCTCoeffFirst(run, level)
  902. unsigned int *run;
  903. int *level;
  904. {
  905.   decodeDCTCoeff(dct_coeff_first, run, level);
  906. }
  907.  
  908.  
  909.  
  910.  
  911. /*
  912.  *--------------------------------------------------------------
  913.  *
  914.  * decodeDCTCoeffNext --
  915.  *
  916.  *    Huffman Decoder for dct_coeff_first. Locations for the
  917.  *      decoded results: run and level, are being passed as
  918.  *      arguments. Actual work is being done by calling DecodeDCTCoeff,
  919.  *      with the table dct_coeff_next.
  920.  *
  921.  * Results:
  922.  *    The decoded values of run and level for dct_coeff_next or
  923.  *      ERROR for unbound values are placed in the locations given.
  924.  *
  925.  * Side effects:
  926.  *    Bit stream is irreversibly parsed.
  927.  *
  928.  *--------------------------------------------------------------
  929.  */ 
  930. void       
  931. decodeDCTCoeffNext(run, level)
  932. unsigned int *run;
  933. int *level;
  934. {
  935.   decodeDCTCoeff(dct_coeff_next, run, level);
  936. }
  937.